<?php


class MYANMAR {

    /* FROM hb-ot-shape-complex-indic-private.hh */
// indic_category
    const OT_X = 0;
    const OT_C = 1;
    const OT_V = 2;
    const OT_N = 3;
    const OT_H = 4;
    const OT_ZWNJ = 5;
    const OT_ZWJ = 6;
    const OT_M = 7;		/* Matra or Dependent Vowel */
    const OT_SM = 8;
    const OT_VD = 9;
    const OT_A = 10;
    const OT_NBSP = 11;
    const OT_DOTTEDCIRCLE = 12;	/* Not in the spec, but special in Uniscribe. /Very very/ special! */
    const OT_RS = 13; 		/* Register Shifter, used in Khmer OT spec */
    const OT_Coeng = 14;
    const OT_Repha = 15;
    const OT_Ra = 16; 		/* Not explicitly listed in the OT spec, but used in the grammar. */
    const OT_CM = 17;

    /* FROM hb-ot-shape-complex-myanmar.hh */
// myanmar_category
    const OT_DB  = 3;  // same as INDIC::OT_N; /* Dot below */
    const OT_GB  = 12;  // same as INDIC::OT_DOTTEDCIRCLE;

    const OT_As  = 18; /* Asat */
    const OT_D   = 19; /* Digits except zero */
    const OT_D0  = 20; /* Digit zero */
    const OT_MH  = 21; /* Various consonant medial types */
    const OT_MR  = 22; /* Various consonant medial types */
    const OT_MW  = 23; /* Various consonant medial types */
    const OT_MY  = 24; /* Various consonant medial types */
    const OT_PT  = 25; /* Pwo and other tones */
    const OT_VAbv = 26;
    const OT_VBlw = 27;
    const OT_VPre = 28;
    const OT_VPst = 29;
    const OT_VS   = 30; /* Variation selectors */


// Based on myanmar_category used to make string to find syllables
// OT_ to string character (using e.g. OT_C from MYANMAR) hb-ot-shape-complex-myanmar-private.hh
    public static $myanmar_category_char = array(
        'x',
        'C',
        'V',
        'N',
        'H',
        'Z',
        'J',
        'x',
        'S',
        'x',
        'A',
        'x',
        'D',
        'x',
        'x',
        'x',
        'R',
        'x',


        'a',	/* As Asat */
        'd',	/* Digits except zero */
        'o',	/* Digit zero */
        'k',	/* Medial types */
        'l',	/* Medial types */
        'm',	/* Medial types */
        'n',	/* Medial types */
        'p',	/* Pwo and other tones */
        'v',	/* Vowel aboVe */
        'b',	/* Vowel Below */
        'e',	/* Vowel prE */
        't',	/* Vowel posT */
        's',	/* variation Selector */

    );


    /* Visual positions in a syllable from left to right. */
    /* FROM hb-ot-shape-complex-myanmar-private.hh */
// myanmar_position
    const POS_START = 0;

    const POS_RA_TO_BECOME_REPH = 1;
    const POS_PRE_M = 2;
    const POS_PRE_C = 3;

    const POS_BASE_C = 4;
    const POS_AFTER_MAIN = 5;

    const POS_ABOVE_C = 6;

    const POS_BEFORE_SUB = 7;
    const POS_BELOW_C = 8;
    const POS_AFTER_SUB = 9;

    const POS_BEFORE_POST = 10;
    const POS_POST_C = 11;
    const POS_AFTER_POST = 12;

    const POS_FINAL_C = 13;
    const POS_SMVD = 14;

    const POS_END = 15;



    public static function set_myanmar_properties(&$info) {
        $u = $info['uni'];
        $type = self::myanmar_get_categories($u);
        $cat = ($type & 0x7F);
        $pos = ($type >> 8);
        /*
        * Re-assign category
        * http://www.microsoft.com/typography/OpenTypeDev/myanmar/intro.htm#analyze
        */
        if (self::in_range($u, 0xFE00, 0xFE0F))
            $cat = self::OT_VS;
        else if ($u == 0x200C) $cat = self::OT_ZWNJ;
        else if ($u == 0x200D) $cat = self::OT_ZWJ;

        switch ($u) {
            case 0x002D: case 0x00A0: case 0x00D7: case 0x2012:
            case 0x2013: case 0x2014: case 0x2015: case 0x2022:
            case 0x25CC: case 0x25FB: case 0x25FC: case 0x25FD:
            case 0x25FE:
                $cat = self::OT_GB;
                break;

            case 0x1004: case 0x101B: case 0x105A:
            $cat = self::OT_Ra;
            break;

            case 0x1032: case 0x1036:
            $cat = self::OT_A;
            break;

            case 0x103A:
                $cat = self::OT_As;
                break;

            case 0x1041: case 0x1042: case 0x1043: case 0x1044:
            case 0x1045: case 0x1046: case 0x1047: case 0x1048:
            case 0x1049: case 0x1090: case 0x1091: case 0x1092:
            case 0x1093: case 0x1094: case 0x1095: case 0x1096:
            case 0x1097: case 0x1098: case 0x1099:
            $cat = self::OT_D;
            break;

            case 0x1040:
                $cat = self::OT_D; /* XXX The spec says D0, but Uniscribe doesn't seem to do. */
                break;

            case 0x103E: case 0x1060:
            $cat = self::OT_MH;
            break;

            case 0x103C:
                $cat = self::OT_MR;
                break;

            case 0x103D: case 0x1082:
            $cat = self::OT_MW;
            break;

            case 0x103B: case 0x105E: case 0x105F:
            $cat = self::OT_MY;
            break;

            case 0x1063: case 0x1064: case 0x1069: case 0x106A:
            case 0x106B: case 0x106C: case 0x106D: case 0xAA7B:
            $cat = self::OT_PT;
            break;

            case 0x1038: case 0x1087: case 0x1088: case 0x1089:
            case 0x108A: case 0x108B: case 0x108C: case 0x108D:
            case 0x108F: case 0x109A: case 0x109B: case 0x109C:
            $cat = self::OT_SM;
            break;
        }

        if ($cat == self::OT_M) {
            switch ($pos) {
                case self::POS_PRE_C:
                    $cat = self::OT_VPre;
                    $pos = self::POS_PRE_M;
                    break;
                case self::POS_ABOVE_C:	$cat = self::OT_VAbv; break;
                case self::POS_BELOW_C:	$cat = self::OT_VBlw; break;
                case self::POS_POST_C:	$cat = self::OT_VPst; break;
            }
        }
        $info['myanmar_category'] = $cat;
        $info['myanmar_position'] = $pos;
    }

// syllable_type
    const CONSONANT_SYLLABLE = 0;
    const BROKEN_CLUSTER = 3;
    const NON_MYANMAR_CLUSTER = 4;



    public static function set_syllables(&$o, $s, &$broken_syllables) {
        $ptr = 0;
        $syllable_serial = 1;
        $broken_syllables = false;

        while($ptr < strlen($s)) {
            $match = '';
            $syllable_length = 1;
            $syllable_type = self::NON_MYANMAR_CLUSTER ;
            // CONSONANT_SYLLABLE Consonant syllable
            // From OT spec:
            if (preg_match('/^(RaH)?([C|R]|V|d|D)[s]?(H([C|R|V])[s]?)*(H|[a]*[n]?[l]?((m[k]?|k)[a]?)?[e]*[v]*[b]*[A]*(N[a]?)?(t[k]?[a]*[v]*[A]*(N[a]?)?)*(p[A]*(N[a]?)?)*S*[J|Z]?)/', substr($s,$ptr), $ma)) {
                $syllable_length = strlen($ma[0]);
                $syllable_type = self::CONSONANT_SYLLABLE ;
            }

            // BROKEN_CLUSTER syllable
            else if (preg_match('/^(RaH)?s?(H|[a]*[n]?[l]?((m[k]?|k)[a]?)?[e]*[v]*[b]*[A]*(N[a]?)?(t[k]?[a]*[v]*[A]*(N[a]?)?)*(p[A]*(N[a]?)?)*S*[J|Z]?)/', substr($s,$ptr), $ma)) {
                if (strlen($ma[0])) {	// May match blank
                    $syllable_length = strlen($ma[0]);
                    $syllable_type = self::BROKEN_CLUSTER ;
                    $broken_syllables = true;
                }
            }
            for ($i = $ptr; $i < $ptr+$syllable_length; $i++) { $o[$i]['syllable'] = ($syllable_serial << 4) | $syllable_type; }
            $ptr += $syllable_length ;
            $syllable_serial++;
            if ($syllable_serial == 16) $syllable_serial = 1;
        }
    }



    public static function reordering(&$info, $GSUBdata, $broken_syllables, $dottedcircle) {
        if ($broken_syllables && $dottedcircle) { self::insert_dotted_circles ($info, $dottedcircle); }
        $count = count($info);
        if (!$count) return;
        $last = 0;
        $last_syllable = $info[0]['syllable'];
        for ($i = 1; $i < $count; $i++) {
            if ($last_syllable != $info[$i]['syllable']) {
                self::reordering_syllable ($info, $GSUBdata, $last, $i);
                $last = $i;
                $last_syllable = $info[$last]['syllable'];
            }
        }
        self::reordering_syllable($info, $GSUBdata, $last, $count);
    }

    public static function insert_dotted_circles(&$info, $dottedcircle) {
        $idx = 0;
        $last_syllable = 0;
        while ($idx < count($info)) {
            $syllable = $info[$idx]['syllable'];
            $syllable_type = ($syllable & 0x0F);
            if ($last_syllable != $syllable && $syllable_type == self::BROKEN_CLUSTER) {
                $last_syllable = $syllable;
                $dottedcircle[0]['syllable'] = $info[$idx]['syllable'];
                array_splice($info, $idx, 0, $dottedcircle);
            }
            else
                $idx++;
        }
        // In case of final bloken cluster...
        $syllable = $info[$idx]['syllable'];
        $syllable_type = ($syllable & 0x0F);
        if ($last_syllable != $syllable && $syllable_type == self::BROKEN_CLUSTER) {
            $dottedcircle[0]['syllable'] = $info[$idx]['syllable'];
            array_splice($info, $idx, 0, $dottedcircle);
        }
    }



    /* Rules from:
     * https://www.microsoft.com/typography/otfntdev/devanot/shaping.aspx */

    public static function reordering_syllable (&$info, $GSUBdata, $start, $end) {
        /* vowel_syllable: We made the vowels look like consonants. So uses the consonant logic! */
        /* broken_cluster: We already inserted dotted-circles, so just call the standalone_cluster. */

        $syllable_type = ($info[$start]['syllable'] & 0x0F);
        if ($syllable_type==self::NON_MYANMAR_CLUSTER ) { return; }
        if ($syllable_type==self::BROKEN_CLUSTER) {
            //if ($uniscribe_bug_compatible) {
            /* For dotted-circle, this is what Uniscribe does:
            * If dotted-circle is the last glyph, it just does nothing.
            * i.e. It doesn't form Reph. */
            if ($info[$end - 1]['myanmar_category'] == self::OT_DOTTEDCIRCLE) {
                return;
            }
        }

        $base = $end;
        $has_reph = false;
        $limit = $start;

        if (($start + 3 <= $end) &&
            $info[$start]['myanmar_category'] == self::OT_Ra &&
            $info[$start+1]['myanmar_category'] == self::OT_As &&
            $info[$start+2]['myanmar_category'] == self::OT_H ) {
            $limit += 3;
            $base = $start;
            $has_reph = true;
        }

        if (!$has_reph)
            $base = $limit;

        for ($i = $limit; $i < $end; $i++) {
            if (self::is_consonant($info[$i])) {
                $base = $i;
                break;
            }
        }


        /* Reorder! */
        $i = $start;
        for (; $i < $start + ($has_reph ? 3 : 0); $i++)
            $info[$i]['myanmar_position'] = self::POS_AFTER_MAIN;
        for (; $i < $base; $i++)
            $info[$i]['myanmar_position'] = self::POS_PRE_C;
        if ($i < $end) {
            $info[$i]['myanmar_position'] = self::POS_BASE_C;
            $i++;
        }
        $pos = self::POS_AFTER_MAIN;
        /* The following loop may be ugly, but it implements all of
        * Myanmar reordering! */
        for (; $i < $end; $i++) {
            if ($info[$i]['myanmar_category'] == self::OT_MR) /* Pre-base reordering */
            {
                $info[$i]['myanmar_position'] = self::POS_PRE_C;
                continue;
            }
            if ($info[$i]['myanmar_position'] < self::POS_BASE_C) /* Left matra */
            {
                continue;
            }

            if ($pos == self::POS_AFTER_MAIN && $info[$i]['myanmar_category'] == self::OT_VBlw)
            {
                $pos = self::POS_BELOW_C;
                $info[$i]['myanmar_position'] = $pos;
                continue;
            }

            if ($pos == self::POS_BELOW_C && $info[$i]['myanmar_category'] == self::OT_A)
            {
                $info[$i]['myanmar_position'] = self::POS_BEFORE_SUB;
                continue;
            }
            if ($pos == self::POS_BELOW_C && $info[$i]['myanmar_category'] == self::OT_VBlw)
            {
                $info[$i]['myanmar_position'] = $pos;
                continue;
            }
            if ($pos == self::POS_BELOW_C && $info[$i]['myanmar_category'] != self::OT_A)
            {
                $pos = self::POS_AFTER_SUB;
                $info[$i]['myanmar_position'] = $pos;
                continue;
            }
            $info[$i]['myanmar_position'] = $pos;
        }


        /* Sit tight, rock 'n roll! */
        self::bubble_sort ($info, $start, $end - $start);

    }


    public static function is_one_of ($info, $flags) {
        if (isset($info['is_ligature']) && $info['is_ligature']) return false;	/* If it ligated, all bets are off. */
        return !!(self::FLAG($info['myanmar_category']) & $flags);
    }

    /* Vowels and placeholders treated as if they were consonants. */
    public static function is_consonant($info) {
        return self::is_one_of($info, (self::FLAG(self::OT_C) | self::FLAG(self::OT_CM) | self::FLAG(self::OT_Ra) | self::FLAG(self::OT_V) | self::FLAG(self::OT_NBSP) | self::FLAG(self::OT_GB)));
    }



// From hb-private.hh
    public static function in_range ($u, $lo, $hi) {
        if ( (($lo^$hi) & $lo) == 0 && (($lo^$hi) & $hi) == ($lo^$hi) && (($lo^$hi) & (($lo^$hi) + 1)) == 0 )
            return ($u & ~($lo^$hi)) == $lo;
        else
            return $lo <= $u && $u <= $hi;
    }

// From hb-private.hh
    public static function FLAG($x) { return (1<<($x)); }

    public static function FLAG_RANGE($x,$y) { self::FLAG(y+1) - self::FLAG(x); }



// BELOW from hb-ot-shape-complex-indic.cc
// see INDIC for details

    public static $myanmar_table = array(

        /* Myanmar  (1000..109F) */

        /* 1000 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* 1008 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* 1010 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* 1018 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* 1020 */  3841, 3842, 3842, 3842, 3842, 3842, 3842, 3842,
        /* 1028 */  3842, 3842, 3842,  2823,  2823,  1543,  1543,  2055,
        /* 1030 */  2055,  775,  1543,  1543,  1543,  1543, 3848, 3843,
        /* 1038 */  3848,  3844,  1540, 3857, 3857, 3857, 3857,  3841,
        /* 1040 */  3840,  3840,  3840,  3840,  3840,  3840,  3840,  3840,
        /* 1048 */  3840,  3840,  3840,  3840,  3840,  3840,  3840,  3840,
        /* 1050 */  3841,  3841, 3842, 3842, 3842, 3842,  2823,  2823,
        /* 1058 */  2055,  2055,  3841,  3841,  3841,  3841, 3857, 3857,
        /* 1060 */  3857,  3841,  2823, 3843, 3843,  3841,  3841,  2823,
        /* 1068 */  2823, 3843, 3843, 3843, 3843, 3843,  3841,  3841,
        /* 1070 */  3841,  1543,  1543,  1543,  1543,  3841,  3841,  3841,
        /* 1078 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* 1080 */  3841,  3841, 3857,  2823,  775,  1543,  1543, 3843,
        /* 1088 */  3843, 3843, 3843, 3843, 3843, 3843,  3841, 3843,
        /* 1090 */  3840,  3840,  3840,  3840,  3840,  3840,  3840,  3840,
        /* 1098 */  3840,  3840, 3843, 3843,  2823,  1543,  3840,  3840,

        /* Myanmar Extended-A  (AA60..AA7F) */

        /* AA60 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* AA68 */  3841,  3841,  3841,  3841,  3841,  3841,  3841,  3841,
        /* AA70 */  3840,  3841,  3841,  3841,  3840,  3840,  3840,  3840,
        /* AA78 */  3840,  3840,  3841, 3843,  3840,  3840,  3840,  3840,


    );

// from "hb-ot-shape-complex-indic-table.cc"
    public static function myanmar_get_categories ($u) {
        if (0x1000 <= $u && $u <= 0x109F) return self::$myanmar_table[$u - 0x1000 + 0];	// offset 0 for Most "myanmar"
        if (0xAA60 <= $u && $u <= 0xAA7F) return self::$myanmar_table[$u - 0xAA60 + 160];	// offset for extensions
        if ($u == 0x00A0) return 3851;	// (ISC_CP | (IMC_x << 8))
        if ($u == 0x25CC) return 3851;	// (ISC_CP | (IMC_x << 8))
        return 3840;	// (ISC_x | (IMC_x << 8))
    }


    public static function bubble_sort(&$arr, $start, $len) {
        if ($len<2) { return;}
        $k = $start+$len-2;
        while ($k >= $start) {
            for ($j=$start; $j<=$k; $j++) {
                if ($arr[$j]['myanmar_position'] > $arr[$j + 1]['myanmar_position']) {
                    $t = $arr[$j];
                    $arr[$j] = $arr[$j + 1];
                    $arr[$j + 1] = $t;
                }
            }
            $k--;
        }
    }




}	// end Class

?>